import { TColumn, TDataRow } from '@/components/editable-excel-table';

export interface ErrorPosition {
    rowIndex: number;
    columnIndex: number;
}

export interface ErrorStats {
    totalErrors: number; // 总错误数（包含已修改与未修改）
    errorPositions: ErrorPosition[]; // 所有错误的单元格位置
    rowErrors: Set<number>; // 有错误的行索引
    fixedErrorCount: number; // 已修改的错误数量
    remainingErrorPositions: ErrorPosition[]; // 未修改的错误位置
}

/**
 * 统计表格中的错误信息
 */
export function calculateErrorStats<C extends TColumn>(
    data: TDataRow<C>[],
    columns: C[],
    initialData?: TDataRow<C>[],
    // 修改的单元格
    modifiedCells?: Set<string>
): ErrorStats {
    const errorPositions: ErrorPosition[] = [];
    const remainingErrorPositions: ErrorPosition[] = [];
    const rowErrors = new Set<number>();
    let totalErrors = 0;
    let fixedErrorCount = 0;

    // console.log('&&&&&&&&&&&&&&&&&&&&&&');
    // console.log('modifiedCells', modifiedCells);

    data.forEach((row, rowIndex) => {
        let hasRowError = false;

        // 检查行级别的错误
        if (row._errors) {
            row._errors.forEach((error) => {
                if (typeof error.column === 'number') {
                    // 单元格错误
                    const columnFixIndex = error.column + 1; // +1是因为columns 默认有序号列

                    errorPositions.push({ rowIndex, columnIndex: columnFixIndex });
                    totalErrors++;

                    // 检查是否已修改，只有未修改的错误才计入导航
                    if (initialData && modifiedCells) {
                        const dataIndex = columns[columnFixIndex]?.dataIndex;

                        if (dataIndex) {
                            const key = `${rowIndex}:${dataIndex}`;
                            const currentValue = (data[rowIndex] as any)?.[dataIndex];
                            const initialValue = (initialData[rowIndex] as any)?.[dataIndex];
                            if (modifiedCells.has(key) && currentValue !== initialValue) {
                                fixedErrorCount++;
                                // 已修改的错误不加入导航列表
                            } else {
                                // 未修改的错误才加入导航列表
                                remainingErrorPositions.push({ rowIndex, columnIndex: columnFixIndex });
                            }
                        }
                    } else {
                        // 如果没有初始数据或修改记录，所有错误都计入导航
                        remainingErrorPositions.push({ rowIndex, columnIndex: columnFixIndex });
                    }
                } else {
                    // 行级别错误
                    hasRowError = true;
                    columns
                        // 忽略序号列
                        .filter((column) => column.dataIndex !== '__index__')
                        .map((column, columnIndex) => {
                            const colIdx = columnIndex + 1;
                            errorPositions.push({ rowIndex, columnIndex: colIdx });
                            totalErrors++;

                            // 检查是否已修改，只有未修改的错误才计入导航
                            if (initialData && modifiedCells) {
                                const dataIndex = column.dataIndex;
                                const key = `${rowIndex}:${dataIndex}`;
                                const currentValue = (data[rowIndex] as any)?.[dataIndex];
                                const initialValue = (initialData[rowIndex] as any)?.[dataIndex];
                                if (modifiedCells.has(key) && currentValue !== initialValue) {
                                    fixedErrorCount++;
                                    // 已修改的错误不加入导航列表
                                } else {
                                    // 未修改的错误才加入导航列表
                                    remainingErrorPositions.push({ rowIndex, columnIndex: colIdx });
                                }
                            } else {
                                // 如果没有初始数据或修改记录，所有错误都计入导航
                                remainingErrorPositions.push({ rowIndex, columnIndex: colIdx });
                            }
                        });
                }
            });
        }

        if (hasRowError) {
            rowErrors.add(rowIndex);
        }
    });

    // // 调试信息
    // console.log('ErrorStats Debug **********************:', {
    //     totalErrors,
    //     fixedErrorCount,
    //     remainingErrorPositions: remainingErrorPositions.length,
    //     modifiedCells: modifiedCells ? Array.from(modifiedCells) : [],
    //     initialDataLength: initialData?.length || 0,
    // });

    return {
        // 总错误数
        totalErrors,
        // 所有错误位置
        errorPositions,
        // 有错误的行
        rowErrors,
        // 已修改的错误数量
        fixedErrorCount,
        // 未修改的错误位置
        remainingErrorPositions,
    };
}

/**
 * 获取错误对象，用于RowRenderer
 */
export function getErrorObject<C extends TColumn>(
    rowIndex: number,
    errorStats: ErrorStats,
    errorMessage: string = '数据错误'
): Record<number, string> & { thisLineError?: boolean } {
    const errorObject: Record<number, string> & { thisLineError?: boolean } = {};

    // 检查是否有行级别错误
    errorObject.thisLineError = errorStats.rowErrors.has(rowIndex);

    // 添加单元格错误
    errorStats.errorPositions
        .filter((pos) => pos.rowIndex === rowIndex)
        .forEach((pos) => {
            errorObject[pos.columnIndex] = errorMessage;
        });

    return errorObject;
}
